home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Archives / GNU / GNUPLOTsrc.lha / term / hp26.trm < prev    next >
Encoding:
Text File  |  1996-01-22  |  18.0 KB  |  686 lines
  1. /*
  2.  * $Id: hp26.trm,v 1.7 1995/12/20 21:47:51 drd Exp $
  3.  */
  4.  
  5. /* GNUPLOT - HP26.trm */
  6. /*
  7.  * Copyright (C) 1990   
  8.  *
  9.  * Permission to use, copy, and distribute this software and its
  10.  * documentation for any purpose with or without fee is hereby granted, 
  11.  * provided that the above copyright notice appear in all copies and 
  12.  * that both that copyright notice and this permission notice appear 
  13.  * in supporting documentation.
  14.  *
  15.  * Permission to modify the software is granted, but not the right to
  16.  * distribute the modified code.  Modifications are to be distributed 
  17.  * as patches to released version.
  18.  *  
  19.  * This software  is provided "as is" without express or implied warranty.
  20.  * 
  21.  * This file is included by ../term.c.
  22.  *
  23.  * This terminal driver supports:
  24.  *  HP2623A 
  25.  *
  26.  * AUTHORS
  27.  *   luecken@udel.edu (Bruce Lueckenhoff) 
  28.  *   hplvlch!ch (Chuck Heller) 
  29.  * 
  30.  * send your comments or suggestions to (info-gnuplot@dartmouth.edu).
  31.  * 
  32.  */
  33.  
  34. /*
  35.  * adapted to the new terminal layout by Stefan Bodewig (Dec. 1995)
  36.  */
  37.  
  38. #ifndef GOT_DRIVER_H
  39. #include "driver.h"
  40. #endif
  41.  
  42. #ifdef TERM_REGISTER
  43. register_term(hp2623a)
  44. #endif
  45.  
  46. #ifdef TERM_PROTO
  47. TERM_PUBLIC void HP26_vector __P((unsigned int x, unsigned int y));
  48. TERM_PUBLIC void HP26_move __P((unsigned int x, unsigned int y));
  49. TERM_PUBLIC void HP26_init __P((void));
  50. TERM_PUBLIC void HP26_graphics __P((void));
  51. TERM_PUBLIC void HP26_text __P((void));
  52. TERM_PUBLIC void HP26_reset __P((void));
  53. TERM_PUBLIC int HP26_text_angle __P((int ang));
  54. TERM_PUBLIC void HP26_put_text __P((unsigned int x, unsigned int y, char *str));
  55. TERM_PUBLIC void HP26_linetype __P((int linetype));
  56. TERM_PUBLIC void HP26_line_and_point __P((unsigned int x, unsigned int y, int number));
  57.  
  58. #define HP26_XMAX 512
  59. #define HP26_YMAX 390
  60.  
  61. /* Use a size 1 character, or a 7 x 10 grid. */
  62. #define HP26_VCHAR    10
  63. #define HP26_HCHAR    7
  64. #define HP26_VTIC    5
  65. #define HP26_HTIC    5
  66. #endif /* TERM_PROTO */
  67.  
  68. #ifndef TERM_PROTO_ONLY
  69. #ifdef TERM_BODY
  70. /* include the stream compaction routines */
  71.  
  72. #define HP26_XLAST (HP26_XMAX - 1)
  73. #define HP26_YLAST (HP26_XMAX - 1)
  74.  
  75. void HP26_do_point __P((unsigned int x, unsigned int y, int number));
  76. int compact_slope __P((int xp[], int yp[], int isa_move[], int *sz, double delta));
  77. int compact_int __P((int xp[], int yp[], int isa_move[], int *size));
  78. struct _HP26_Buffer_Node *BN_create __P((int index, int size, int linetype));
  79. void BN_delete __P((struct _HP26_Buffer_Node *the_node));
  80. int HP26_flush __P((struct _HP26_Buffer_Node *the_buff));
  81. void HP26_handle_overflow __P((void));
  82.  
  83. #include "compact.c"
  84.  
  85. typedef struct _HP26_Buffer_Node{
  86.     int index;
  87.     int size;
  88.     int next;
  89.     int linetype;
  90.     int *x;
  91.     int *y;
  92.     TBOOLEAN *isa_move;
  93. } HP26_Buffer_Node;
  94.  
  95. /* constructor method */
  96. HP26_Buffer_Node *BN_create(index, size, linetype)
  97. int index, size, linetype;
  98. {
  99.     HP26_Buffer_Node *the_node;
  100.     the_node = (HP26_Buffer_Node *) malloc(sizeof(HP26_Buffer_Node));
  101.     the_node->index = index;
  102.     the_node->linetype = linetype;
  103.     the_node->size = size;
  104.     the_node->next = 0;
  105.     the_node->x = (int *) calloc(the_node->size, sizeof(int));
  106.     the_node->y = (int *) calloc(the_node->size, sizeof(int));
  107.     the_node->isa_move = (TBOOLEAN *)calloc(the_node->size,sizeof(TBOOLEAN));
  108.     if (the_node->x == NULL 
  109.       ||the_node->y == NULL 
  110.       ||the_node->isa_move == NULL)
  111.         return (NULL);
  112.     else
  113.         return(the_node);
  114. }
  115.  
  116. /* destructor method */
  117. void BN_delete(the_node)
  118. HP26_Buffer_Node *the_node;
  119. {
  120.     free(the_node->x);
  121.     free(the_node->y);
  122.     free(the_node->isa_move);
  123.     free(the_node);
  124. }
  125.  
  126. /* 2 for border and axes + 9 for plots + 1 for dots */
  127. #define HP26_gnu_map_size 12
  128. HP26_Buffer_Node *HP26_gnu_map[HP26_gnu_map_size];
  129. HP26_Buffer_Node *HP26_buff;
  130. int HP26_pen_x;
  131. int HP26_pen_y;
  132. int HP26_angle;
  133. int HP26_cursor_x;
  134. int HP26_cursor_y;
  135. TBOOLEAN HP26_in_text;
  136. int HP26_linetype_current;
  137. int HP26_reduction_int;
  138. int HP26_reduction_slope;
  139. int HP26_overflows;
  140. int HP26_nop_move;
  141. int HP26_nop_vect;
  142. int HP26_nop_line;
  143.  
  144. /* linetype stuff */
  145. #define    SOLID    1
  146. #define    USER    2
  147. #define LINE3    3
  148. #define LINE4    4
  149. #define LINE5    5
  150. #define LINE6    6
  151. #define    DOTS    7
  152. #define LINE8    8
  153. #define LINE9    9
  154. #define LINE10    10
  155. #define POINT    11
  156.  
  157.  
  158.  
  159. #define swap(a, b) a ^= b; b ^= a; a ^= b;
  160.  
  161. char HP26_bin_short_table[32]={
  162. '0','1','2','3','4','5','6','7','8','9',':',';','<','=','>','?',
  163. ' ','!','"','#','$','%','&','\'','(',')','*','+',',','-','.','/'};
  164. /* encodes an integer (assumed to be in range) into 
  165.    binary short incremental format (j)*/
  166. #define short_encode(n) (HP26_bin_short_table[n+16])
  167.  
  168. /* tells whether a given delta_x,delta_y pair can be expressed in
  169.    binary short incremental format */
  170. #define qualified(dx,dy) ((dx>-17)&&(dy>-17)&&(dx<16)&&(dy<16))
  171.  
  172.  
  173. char HP26_bin_table[32]={
  174. ' ','!','"','#','$','%','&','\'','(',')','*','+',',','-','.','/',
  175. '0','1','2','3','4','5','6','7','8','9',':',';','<','=','>','?'};
  176. /* returns the high byte of integer n in binary absolute format (i) */
  177. #define bin_encode_hi(n) (HP26_bin_table[n>>5]) 
  178. /* returns the low byte of integer n in binary absolute format (i) */
  179. #define bin_encode_lo(n) (HP26_bin_table[n & 31]) 
  180.  
  181.  
  182.  
  183. /* the guts of the program 
  184. -- first checks if any work need be done and, failing that, returns 
  185.     immediately
  186. -- tries to compress the vector stream
  187. -- goes through the buffer, using binary short incremental (2 bytes/point) 
  188.     as much as possible, even if must output two pairs to express one vector
  189.     (it's no more expensive, and will hopefully damp any excessive switching
  190.     back and forth between the two formats)
  191.     if can't use binary short incremental, use binary 
  192.     absolute(4 bytes/point)
  193. -- finally, resets the HP26_next pointer to zero    */
  194. int HP26_flush(the_buff)
  195. HP26_Buffer_Node *the_buff;
  196. {
  197.     int i, delta_x, delta_y, half_dx, half_dy;
  198.     int *buff_x, *buff_y;
  199.     TBOOLEAN *isa_move;
  200.     TBOOLEAN bin_short;
  201.  
  202.     if (the_buff->next == 0)
  203.         return (FALSE);
  204.     /* init pointers for easy access */
  205.     buff_x = the_buff->x;
  206.     buff_y = the_buff->y;
  207.     isa_move = the_buff->isa_move;
  208.     if (HP26_in_text){
  209.         fputs("\033*dT", outfile);
  210.         HP26_in_text = FALSE;
  211.     }
  212.     if (HP26_linetype_current != the_buff->linetype
  213.         && (the_buff->next > 1 || !isa_move[0])){
  214.         fprintf(outfile,"\033*m%dB",the_buff->linetype);
  215.         HP26_linetype_current = the_buff->linetype;
  216.     }
  217.     /* try to compress the stream */
  218.     if (the_buff->next>30 && the_buff->linetype != POINT){
  219. /*        HP26_reduction_int += compact_int(buff_x,buff_y,isa_move, &(the_buff->next));    */
  220.         HP26_reduction_slope += compact_slope(buff_x,buff_y,isa_move, &(the_buff->next),0.1); 
  221.     }
  222.  
  223.     /* start escape sequence */
  224.     fputs("\033*p",outfile);
  225.     /* initialize the state:  binary short incremental or binary absolute */
  226.     delta_x = buff_x[0] - HP26_pen_x;
  227.     delta_y = buff_y[0] - HP26_pen_y;
  228.     if (qualified(delta_x, delta_y)){
  229.         fputc('j', outfile);
  230.         bin_short = TRUE;
  231.     }else{
  232.         fputc('i', outfile);
  233.         bin_short = FALSE;
  234.     }
  235.     /* now work through the list */
  236.     for (i=0;i<the_buff->next;i++){
  237.         if (i>0){
  238.             delta_x = buff_x[i] - buff_x[i-1];
  239.             delta_y = buff_y[i] - buff_y[i-1];
  240.         }
  241.         if ((delta_x==0)&&(delta_y==0)){
  242.             if (i>0 && !isa_move[i-1] && !isa_move[i]){
  243.                 /* allow null vectors only when drawing dots */
  244.                 HP26_nop_vect++;
  245.                 continue;
  246.             }else if (isa_move[i]){
  247.                 /* a null move */
  248.                 HP26_nop_move++;
  249.                 continue;
  250.             }
  251.         }else if (i > 0
  252.             && i+1 <the_buff->next
  253.             && isa_move[i]
  254.             && isa_move[i+1]){
  255.             /* consecutive moves are condensed into one */
  256.             HP26_nop_move++;
  257.             continue;
  258.         }else if (!qualified(delta_x, delta_y)
  259.           && i > 0
  260.           && i + 2 < the_buff->next
  261.           && isa_move[i]
  262.           && !isa_move[i+1]
  263.           && isa_move[i+2]
  264.           &&qualified(buff_x[i+1]-buff_x[i-1],buff_y[i+1]-buff_y[i-1])){
  265.             swap(buff_x[i], buff_x[i+1]);
  266.             swap(buff_y[i], buff_y[i+1]);
  267.             /* set up new delta_x & delta_y */
  268.             delta_x = buff_x[i] - buff_x[i-1];
  269.             delta_y = buff_y[i] - buff_y[i-1];
  270.         }
  271.         if (qualified(delta_x,delta_y)){
  272.             if (!bin_short){
  273.                 fputc ('j',outfile);
  274.                 bin_short = TRUE;
  275.             }
  276.             if (isa_move[i])
  277.                 fputc ('a',outfile);
  278.             fputc(short_encode(delta_x), outfile);
  279.             fputc(short_encode(delta_y), outfile);
  280.         }else{
  281.             half_dx = (delta_x + (delta_x>0 ? 1 : -1))/2;
  282.             half_dy = (delta_y + (delta_y>0 ? 1 : -1))/2;
  283.             if (bin_short && qualified(half_dx,half_dy)){
  284.                 if (isa_move[i])
  285.                     fputc('a',outfile);
  286.                 fputc(short_encode(half_dx), outfile);
  287.                 fputc(short_encode(half_dy), outfile);
  288.                 if (isa_move[i])
  289.                     fputc('a',outfile);
  290.                 fputc(short_encode(delta_x - half_dx), outfile);
  291.                 fputc(short_encode(delta_y - half_dy), outfile);
  292.             }else{ 
  293.                 if (bin_short){
  294.                     bin_short = FALSE;
  295.                     fputc('i',outfile);
  296.                 }
  297.                 if (isa_move[i])
  298.                     fputc('a',outfile);
  299.                 fputc(bin_encode_hi(buff_x[i]), outfile);
  300.                 fputc(bin_encode_lo(buff_x[i]), outfile);
  301.                 fputc(bin_encode_hi(buff_y[i]), outfile);
  302.                 fputc(bin_encode_lo(buff_y[i]), outfile);
  303.             }
  304.         }
  305.     }    /* end for.. */
  306.     /* the term doesn't seem to mind leaving this out */
  307.     /* finish the escape sequence */
  308.     fputc ('Z',outfile);
  309.     /* set these for next time */
  310.     HP26_pen_x = buff_x[the_buff->next - 1];
  311.     HP26_pen_y = buff_y[the_buff->next - 1];
  312.     the_buff->next = 0;
  313.     return(TRUE);
  314. }
  315.  
  316. void HP26_handle_overflow()
  317. {
  318.     HP26_Buffer_Node *bigger, *old;
  319.     int x, y;
  320.     x = (HP26_buff->x)[HP26_buff->next - 1];
  321.     y = (HP26_buff->y)[HP26_buff->next - 1];
  322.     HP26_flush(HP26_buff);
  323.     bigger = BN_create(HP26_buff->index, HP26_buff->size * 2,
  324.         HP26_buff->linetype);
  325.     if (bigger != NULL){
  326.         old = HP26_buff;
  327.         HP26_gnu_map[bigger->index] = bigger;
  328.         /* special case since DOTS entry is shared 3 ways */
  329.         if(bigger->index == 0){
  330.             HP26_gnu_map[1] = bigger;
  331.             HP26_gnu_map[3] = bigger;
  332.         }
  333.         HP26_buff = bigger;
  334.         BN_delete(old);
  335.     }
  336.     (HP26_buff->x)[0] = x;
  337.     (HP26_buff->y)[0] = y;
  338.     (HP26_buff->isa_move)[0] = TRUE;
  339.     HP26_buff->next = 1;
  340.     HP26_overflows++;
  341. }
  342.  
  343. /* checks for NOP, overcapacity condition, and then adds vector to the list */
  344. TERM_PUBLIC void HP26_vector(x,y)
  345. unsigned int x,y;
  346. {
  347.     if (HP26_buff->next > 2
  348.       && x == (HP26_buff->x)[HP26_buff->next-1]
  349.       && y == (HP26_buff->y)[HP26_buff->next-1]
  350.       && !(HP26_buff->isa_move)[HP26_buff->next-1] ){
  351.         HP26_nop_vect++;
  352.         return;
  353.     }
  354.     if (HP26_buff->next == HP26_buff->size)
  355.         HP26_handle_overflow();
  356.     /* otherwise add to the list */
  357.     (HP26_buff->x)[HP26_buff->next] = x;
  358.     (HP26_buff->y)[HP26_buff->next] = y;
  359.     (HP26_buff->isa_move)[HP26_buff->next] = FALSE;
  360.     HP26_buff->next++;
  361. }
  362.  
  363. /* checks for NOP, checks for overcapacity, puts self on list */
  364. TERM_PUBLIC void HP26_move(x,y)
  365. unsigned int x,y;
  366. {
  367.     if (HP26_buff->next > 0){
  368.         if (((HP26_buff->x)[HP26_buff->next - 1] == x)
  369.           &&((HP26_buff->y)[HP26_buff->next - 1] == y)){
  370.             /* null moves are NOP's */
  371.             HP26_nop_move++;
  372.             return;
  373.         }else if ((HP26_buff->isa_move)[HP26_buff->next-1]){
  374.             /* consecutive moves are NOP's */
  375.             (HP26_buff->x)[HP26_buff->next-1] = x;
  376.             (HP26_buff->y)[HP26_buff->next-1] = y;
  377.             HP26_nop_move++;
  378.             return;
  379.         }
  380.     }
  381.     if (HP26_buff->next == HP26_buff->size)
  382.         HP26_handle_overflow();
  383.     (HP26_buff->x)[HP26_buff->next] = x;
  384.     (HP26_buff->y)[HP26_buff->next] = y;
  385.     (HP26_buff->isa_move)[HP26_buff->next] = TRUE;
  386.     HP26_buff->next++;
  387.     return;
  388. }
  389.  
  390. TERM_PUBLIC void HP26_init()
  391. {
  392.     HP26_gnu_map[-2 + 2] = BN_create( 0, 2048, DOTS);    /* border */
  393.     HP26_gnu_map[-1 + 2] = HP26_gnu_map[-2 + 2];        /* axes */
  394.     HP26_gnu_map[ 0 + 2] = BN_create( 2, 3072, SOLID);    /* plot 0 */
  395.     HP26_gnu_map[ 1 + 2] = HP26_gnu_map[-2 + 2];        /* plot 1 */
  396.     HP26_gnu_map[ 2 + 2] = BN_create( 4, 1024, LINE5);    /* plot 2 */
  397.     HP26_gnu_map[ 3 + 2] = BN_create( 5,  256, LINE6);    /* plot 3 */
  398.     HP26_gnu_map[ 4 + 2] = BN_create( 6,  256, LINE8);    /* plot 4 */
  399.     HP26_gnu_map[ 5 + 2] = BN_create( 7,  128, LINE9);    /* plot 5 */
  400.     HP26_gnu_map[ 6 + 2] = BN_create( 8,  128, LINE10);    /* plot 6 */
  401.     HP26_gnu_map[ 7 + 2] = BN_create( 9,   64, LINE6);    /* plot 7 */
  402.     HP26_gnu_map[ 8 + 2] = BN_create(10,   64, LINE4);    /* plot 8 */
  403.     HP26_gnu_map[ 9 + 2] = BN_create(11,  512, POINT);    /* point plot */
  404.     HP26_buff = HP26_gnu_map[10];    /* set to an unlikely linetype */
  405.     HP26_linetype_current = 0;    /* set to force a linetype change */
  406.     HP26_angle = 1;            /* left to right, default */
  407.     fputs("\033*mp1m2a2Q",outfile);
  408.     /*           1 2 3 4
  409.     1.  make text upright
  410.     2.  select text size 1
  411.     3.  make SET the default drawing op
  412.     4.  left justify text */
  413.     fflush (outfile);
  414. }
  415.  
  416.  
  417. TERM_PUBLIC void HP26_graphics()
  418. {
  419.     fputs("\033*daflsC", outfile);
  420.     /*           12345
  421.     1.  clear graphics display
  422.     2.  shut off the alphanumeric display 
  423.     3.  graphics cursor off
  424.     4.  into graphics text mode
  425.     5.  enable graphics display */
  426.     /* set the pen & cursor positions to force an initial absolute move */
  427.     HP26_pen_x     = HP26_pen_y    = -200;
  428.     HP26_cursor_x    = HP26_cursor_y    = 800;
  429.     HP26_in_text = TRUE;
  430.     /* initialize statistics */
  431.     HP26_reduction_int = 0; 
  432.     HP26_reduction_slope = 0;
  433.     HP26_nop_move = 0;
  434.     HP26_nop_vect = 0;
  435.     HP26_nop_line = 0;
  436.     HP26_overflows = 0;
  437. }
  438.  
  439.  
  440. TERM_PUBLIC void HP26_text()
  441. {
  442.     int i, j, curr;
  443.  
  444.     /* always flush the current line first */
  445.     for (i=0;i<HP26_gnu_map_size;i++)
  446.         if ((HP26_gnu_map[i])->linetype == HP26_linetype_current)
  447.             HP26_flush(HP26_gnu_map[i]);
  448.     /* now flush the rest of the lines */
  449.     for (i=0;i<HP26_gnu_map_size;i++){
  450.         HP26_flush(HP26_gnu_map[i]);
  451.         curr = HP26_gnu_map[i] -> linetype;
  452.         for (j=0;j<HP26_gnu_map_size;j++)
  453.             if ((HP26_gnu_map[j])->linetype == curr)
  454.                 HP26_flush(HP26_gnu_map[j]);
  455.     }
  456.     fputs("\033*deT",outfile);
  457.     /*           12
  458.     1. turn on the alphanumeric display
  459.     2. back to text mode */
  460.     fflush(outfile);
  461.     /* informational:  tells how many points compressed, how
  462.        many NOP's of each type, and how many times a buffer
  463.        overflowed during this plot */
  464.     /*
  465.     if(HP26_reduction_int
  466.          + HP26_reduction_slope
  467.          + HP26_nop_move
  468.          + HP26_nop_vect
  469.          + HP26_overflows
  470.          + HP26_nop_line > 0){
  471.         if (HP26_reduction_int>0)
  472.             printf("%d int-compress",HP26_reduction_int);
  473.         if (HP26_reduction_slope>0)
  474.             printf("%d slope-compress",HP26_reduction_slope);
  475.         if (HP26_nop_move>0)
  476.             printf("  %d nop_move",HP26_nop_move);
  477.         if (HP26_nop_vect>0)
  478.             printf("  %d nop_vect",HP26_nop_vect);
  479.         if (HP26_nop_line>0)
  480.             printf("  %d nop_line",HP26_nop_line);
  481.         if (HP26_overflows>0)
  482.             printf("  %d buffer overflows",HP26_overflows);
  483.         printf("\n");
  484.     }
  485.     */
  486. }
  487.  
  488. TERM_PUBLIC void HP26_reset()
  489. {
  490.     int i;
  491.     for (i=2;i<HP26_gnu_map_size;i++)
  492.         BN_delete(HP26_gnu_map[i]);
  493. }
  494.  
  495. TERM_PUBLIC int HP26_text_angle (ang)
  496. int ang;
  497. {
  498.     HP26_angle = ang + 1;
  499.     fprintf(outfile,"\033*m%dN",HP26_angle);
  500.     return(TRUE);
  501. }
  502.  
  503.  
  504. TERM_PUBLIC void HP26_put_text(x, y,str)
  505. unsigned int x, y;
  506. char *str;
  507. {
  508.     char abs_str[10],rel_str[10];
  509.  
  510.     if (!strlen(str))
  511.         return;
  512.     else{
  513.         fputs("\033*d", outfile);
  514.         if (!HP26_in_text){
  515.             fputc('s', outfile);
  516.             HP26_in_text = TRUE;
  517.         }
  518.         sprintf(rel_str,"%d,%dP",x - HP26_cursor_x, y - HP26_cursor_y);
  519.         sprintf(abs_str,"%d,%dO", x, y);
  520.         if (strlen(rel_str) < strlen(abs_str))
  521.             fputs(rel_str, outfile);
  522.         else
  523.             fputs(abs_str, outfile);
  524.         fputs(str, outfile);
  525.         HP26_pen_x = HP26_cursor_x = x;
  526.         HP26_pen_y = HP26_cursor_y = y;
  527.     }
  528.     /*
  529.         tmp = &(HP26_all_buffers[HP26_linetype_current]);
  530.         tmp->x[tmp->next] = x;
  531.         tmp->y[tmp->next] = y;
  532.         tmp->isa_move[tmp->next] = TRUE;
  533.         tmp->next++;
  534.         HP26_flush(tmp);
  535.         fprintf(outfile,"\033*l%s\r",str);
  536.     */
  537.     return;
  538. }
  539.  
  540.  
  541. /* checks for NOP, sets HP26_buff to point to the right buffer */
  542. TERM_PUBLIC void HP26_linetype(linetype)
  543. int linetype;
  544. {
  545.     if (linetype > 8)
  546.         linetype %= 9;
  547.     linetype += 2;
  548.     if (HP26_gnu_map[linetype] == HP26_buff){
  549.         HP26_nop_line++;
  550.         return;    /* gnuplot just sent us another NOP */
  551.     }
  552.     HP26_buff = HP26_gnu_map[linetype];
  553. }
  554.  
  555.  
  556.  
  557. /* switches to a solid linetype and calls do_point, then switches back */
  558. TERM_PUBLIC void HP26_line_and_point(x,y,number)
  559. unsigned int x,y;
  560. int number;
  561. {
  562.     int line_save,not_solid;
  563.  
  564.     /* shut up warnings with dummy initializer  -SB */
  565.     line_save = 0;
  566.     not_solid = (HP26_buff->linetype != SOLID);
  567.     if (not_solid){
  568.         line_save = HP26_buff->linetype;
  569.         HP26_linetype (0);  /*switch to a solid line*/
  570.     }
  571.     HP26_do_point(x, y, number);
  572.     if (not_solid)
  573.         HP26_linetype(line_save);
  574. }
  575.  
  576.  
  577. /* provides 9 point types so they stay in sync with the linetypes 
  578. puts simpler point types first on the assumption they are more
  579. frequently used */
  580. void HP26_do_point (x, y,number)
  581. unsigned int x, y;
  582. int number;
  583. {
  584.     int htic,vtic;
  585.     HP26_Buffer_Node *tmp;
  586.  
  587.     vtic = HP26_VTIC/2;
  588.     htic = HP26_HTIC/2;
  589.     if (number<0){
  590.         /* do a dot -- special case */
  591.         tmp = HP26_buff;
  592.         HP26_buff = HP26_gnu_map[11];    /* point plot */
  593.         HP26_vector(x, y);
  594.         HP26_buff = tmp;
  595.     }
  596.     switch (number % 9){
  597.         case 0:
  598.             /* do triangle */
  599.             HP26_move(x-htic, y-vtic);
  600.             HP26_vector(x, y+vtic);
  601.             HP26_vector(x+htic, y-vtic);
  602.             HP26_vector(x-htic, y-vtic);
  603.             break;
  604.         case 1:
  605.             /* do nambla */
  606.             HP26_move(x-htic, y+vtic);
  607.             HP26_vector(x, y-vtic);
  608.             HP26_vector(x+htic, y+vtic);
  609.             HP26_vector(x-htic, y+vtic);
  610.             break;
  611.         case 2:
  612.             /* do left triangle */
  613.             HP26_move(x-htic, y);
  614.             HP26_vector(x+htic, y+vtic);
  615.             HP26_vector(x+htic, y-vtic);
  616.             HP26_vector(x-htic, y);
  617.             break;
  618.         case 3:
  619.             /* do right triangle */
  620.             HP26_move(x+htic, y);
  621.             HP26_vector(x-htic, y+vtic);
  622.             HP26_vector(x-htic, y-vtic);
  623.             HP26_vector(x+htic, y);
  624.             break;
  625.         case 4:
  626.             /* do box */
  627.             HP26_move(x-htic, y-vtic);
  628.             HP26_vector(x-htic, y+vtic);
  629.             HP26_vector(x+htic, y+vtic);
  630.             HP26_vector(x+htic, y-vtic);
  631.             HP26_vector(x-htic, y-vtic);
  632.             break;
  633.         case 5:
  634.             /* do plus */
  635.             HP26_move(x, y+vtic);
  636.             HP26_vector(x, y-vtic);
  637.             HP26_move(x-htic, y);
  638.             HP26_vector(x+htic, y);
  639.             break;
  640.         case 6:
  641.             /* do X */
  642.             HP26_move(x+htic, y+vtic);
  643.             HP26_vector(x-htic, y-vtic);
  644.             HP26_move(x-htic, y+vtic);
  645.             HP26_vector(x+htic, y-vtic);
  646.             break;
  647.         default:
  648.             /* do diamond */
  649.             HP26_move(x, y-vtic);
  650.             HP26_vector(x-htic, y);
  651.             HP26_vector(x, y+vtic);
  652.             HP26_vector(x+htic, y);
  653.             HP26_vector(x, y-vtic);
  654.             break;
  655.     }
  656. }
  657.  
  658. #endif /* TERM_BODY */
  659.  
  660. #ifdef TERM_TABLE
  661.  
  662. TERM_TABLE_START(hp2623a_driver)
  663.     "hp2623A", "HP2623A and maybe others",
  664.        HP26_XMAX, HP26_YMAX, HP26_VCHAR, HP26_HCHAR,
  665.        HP26_VTIC, HP26_HTIC, options_null, HP26_init, HP26_reset,
  666.        HP26_text, null_scale, HP26_graphics, HP26_move, HP26_vector,
  667.        HP26_linetype, HP26_put_text, HP26_text_angle, 
  668.        null_justify_text, HP26_line_and_point, do_arrow, set_font_null
  669. TERM_TABLE_END(hp2623a_driver)
  670.  
  671. #undef LAST_TERM
  672. #define LAST_TERM hp2623a_driver
  673.  
  674. #endif /* TERM_TABLE */
  675. #endif /* TERM_PROTO_ONLY */
  676.  
  677. /*
  678.  * NAME: hp2623A
  679.  *
  680.  * OPTIONS: none
  681.  *
  682.  * SUPPORTS: HP2623A and maybe others
  683.  *
  684.  * Further Info: Could be a terminal or a plotter, I don't know.
  685.  *
  686.  */